// 数据验证工具函数

class ValidationUtils {
    // 验证用户输入数据
    static validateUserInput(data) {
        const errors = [];
        
        if (!data) {
            errors.push('请求数据不能为空');
            return { isValid: false, errors };
        }
        
        // 检查必填字段是否存在
        if (!data.hasOwnProperty('name')) {
            errors.push('姓名字段不能为空');
        } else if (!this.validateName(data.name)) {
            errors.push('请提供有效的姓名');
        }
        
        if (!data.hasOwnProperty('birthDate')) {
            errors.push('出生日期字段不能为空');
        } else if (!this.validateBirthDate(data.birthDate)) {
            errors.push('请提供有效的出生日期');
        }
        
        if (!data.hasOwnProperty('gender')) {
            errors.push('性别字段不能为空');
        } else if (!this.validateGender(data.gender)) {
            errors.push('请选择有效的性别');
        }
        
        return {
            isValid: errors.length === 0,
            errors
        };
    }
    
    // 验证姓名
    static validateName(name) {
        if (!name || typeof name !== 'string') {
            return false;
        }
        
        const trimmedName = name.trim();
        if (trimmedName.length === 0 || trimmedName.length > 50) {
            return false;
        }
        
        // 检查是否包含有效字符（中文、英文、数字、常见符号）
        const nameRegex = /^[\u4e00-\u9fa5a-zA-Z0-9\s\-_.]+$/;
        return nameRegex.test(trimmedName);
    }
    
    // 验证出生日期
    static validateBirthDate(birthDate) {
        if (!birthDate || typeof birthDate !== 'string') {
            return false;
        }
        
        // 验证日期格式 YYYY-MM-DD
        const dateRegex = /^\d{4}-\d{2}-\d{2}$/;
        if (!dateRegex.test(birthDate)) {
            return false;
        }
        
        const date = new Date(birthDate);
        const now = new Date();
        
        // 检查是否是有效日期
        if (isNaN(date.getTime())) {
            return false;
        }
        
        // 验证日期字符串是否与解析后的日期一致（防止无效日期如2月30日）
        const [year, month, day] = birthDate.split('-').map(Number);
        if (date.getFullYear() !== year || 
            date.getMonth() !== month - 1 || 
            date.getDate() !== day) {
            return false;
        }
        
        // 检查年份是否在合理范围内（1900年到当前年份）
        const currentYear = now.getFullYear();
        
        if (year < 1900) {
            return false;
        }
        
        // 检查日期不能是未来日期（包括未来年份）
        if (date > now) {
            return false;
        }
        
        return true;
    }
    
    // 验证性别
    static validateGender(gender) {
        if (!gender || typeof gender !== 'string') {
            return false;
        }
        
        const validGenders = ['male', 'female'];
        return validGenders.includes(gender.toLowerCase());
    }
    
    // 验证城市名称
    static validateCity(city) {
        if (!city || typeof city !== 'string') {
            return false;
        }
        
        const trimmedCity = city.trim();
        if (trimmedCity.length === 0 || trimmedCity.length > 20) {
            return false;
        }
        
        // 检查是否包含有效字符（主要是中文城市名）
        const cityRegex = /^[\u4e00-\u9fa5a-zA-Z\s]+$/;
        return cityRegex.test(trimmedCity);
    }
}

// 通用验证函数
const validateInput = (data, rules) => {
    const errors = [];
    
    for (const [field, rule] of Object.entries(rules)) {
        const value = data[field];
        
        // 检查必填字段
        if (rule.required && (!value || (typeof value === 'string' && value.trim() === ''))) {
            errors.push(`${field}字段不能为空`);
            continue;
        }
        
        // 如果字段不是必填且为空，跳过其他验证
        if (!rule.required && (!value || (typeof value === 'string' && value.trim() === ''))) {
            continue;
        }
        
        // 类型验证
        if (rule.type && typeof value !== rule.type) {
            errors.push(`${field}字段类型错误`);
            continue;
        }
        
        // 字符串长度验证
        if (rule.type === 'string' && typeof value === 'string') {
            if (rule.minLength && value.trim().length < rule.minLength) {
                errors.push(`${field}字段长度不能少于${rule.minLength}个字符`);
            }
            if (rule.maxLength && value.trim().length > rule.maxLength) {
                errors.push(`${field}字段长度不能超过${rule.maxLength}个字符`);
            }
        }
        
        // 正则表达式验证
        if (rule.pattern && !rule.pattern.test(value)) {
            errors.push(`${field}字段格式不正确`);
        }
    }
    
    return {
        isValid: errors.length === 0,
        errors
    };
};

// 验证中间件
const validateFortuneInput = (req, res, next) => {
    const validation = ValidationUtils.validateUserInput(req.body);
    
    if (!validation.isValid) {
        return res.status(400).json({
            success: false,
            error: '输入数据验证失败',
            details: validation.errors
        });
    }
    
    // 验证可选的城市字段
    if (req.body.city && !ValidationUtils.validateCity(req.body.city)) {
        return res.status(400).json({
            success: false,
            error: '城市名称格式不正确'
        });
    }
    
    next();
};

// 错误处理中间件
const errorHandler = (err, req, res, next) => {
    console.error('Error:', err);
    
    // 如果响应已经发送，交给默认错误处理器
    if (res.headersSent) {
        return next(err);
    }
    
    // 根据错误类型返回不同的响应
    if (err.type === 'entity.parse.failed') {
        return res.status(400).json({
            success: false,
            error: '请求数据格式错误'
        });
    }
    
    // 默认服务器错误
    res.status(500).json({
        success: false,
        error: '服务器内部错误'
    });
};

module.exports = {
    ValidationUtils,
    validateInput,
    validateFortuneInput,
    errorHandler
};